home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / Tickle-4.0 (tcl) / tcl / expecTerm / scrinfo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-17  |  13.4 KB  |  412 lines  |  [TEXT/MPS ]
  1. /* scrinfo.c - access information about screen contents and attributes
  2. ***************************************************************************** 
  3. expecTerm version 1.0 beta
  4. Mark Weissman
  5. Christopher Matheus
  6. Copyright 1992 by GTE Laboratories Incorporated.
  7.  
  8. Portions of this work are in the public domain.  Permission to use,
  9. copy, modify, and distribute this software and its documentation for
  10. any purpose and without fee is hereby granted, provided that the above
  11. copyright notice appear in all copies and that both the copyright
  12. notice and warranty disclaimer appear in supporting documentation, and
  13. that the names of GTE Laboratories or any of their entities not be
  14. used in advertising or publicity pertaining to distribution of the
  15. software without specific, written prior permission.
  16.  
  17. GTE disclaims all warranties with regard to this software, including
  18. all implied warranties of merchantability and fitness for a particular
  19. purpose, even if GTE Laboratories Incorporated knows about the
  20. purpose.  In no event shall GTE be liable for any special, indirect or
  21. consequential damages or any damages whatsoever resulting from loss of
  22. use, data or profits, whether in an action of contract, negligence or
  23. other tortuous action, arising out of or in connection with the use or
  24. performance of this software.
  25.  
  26. This code is based on and may include parts of Don Libes' expect code:
  27.   expect written by: Don Libes, NIST, 2/6/90
  28.   Design and implementation of expect was paid for by U.S. tax
  29.   dollars.  Therefore it is public domain.  However, the author and NIST
  30.   would appreciate credit if this program or parts of it are used.
  31. ******************************************************************************
  32.  
  33. Written by: Chris Matheus  May1992 
  34.             Mark Weissman
  35. */
  36.  
  37. #include <stdio.h>
  38. #include <ctype.h>
  39. #include <tcl.h>
  40. #include "win.h"
  41. #include "global.h"
  42. #include "scrinfo.h"
  43.  
  44. void printsr(sr)
  45. ScreenRegion *sr;
  46. { 
  47.   printf("         screen region: r:%d %d c:%d %d r_r:%d %d r_c:%d %d rrp:%c rcp:%c, casep: %c\n",
  48.       sr->rowmin,sr->rowmax,sr->colmin, sr->colmax,
  49.       sr->relrowmin,sr->relrowmax,sr->relcolmin, sr->relcolmax,
  50.       sr->relrowp, sr->relcolp, sr->casep);
  51. }
  52.  
  53. char *ScreenDumpContents(minrow,maxrow,mincol,maxcol,
  54.               scr_attr_flag, non_print_char, casep)
  55. int maxrow, maxcol, minrow, mincol;
  56. char scr_attr_flag;
  57. char non_print_char;
  58. char casep;
  59. {
  60.     int col, row;
  61.     static char dumpbuf[XMAX*YMAX], *bufp;
  62.     extern char charyx();
  63.     extern char attryx();
  64.  
  65.     /* printf("%d %d %d %d %d\n",minrow,maxrow,mincol,maxcol,scr_attr_flag); */
  66.   
  67.     bufp = dumpbuf;
  68.     if (scr_attr_flag == SCR_ATTRIBUTES) { /* scr_attr_flag: -1 -> attr, 1 -> contents */
  69.     for (row = minrow; row <= maxrow; row++) {
  70.         for (col = mincol; col <= maxcol; col++)
  71.         *bufp++ = (charyx(row,col)) ? attryx(row,col) :  '_';
  72.         if (row < maxrow) *bufp++ = '\n';
  73.     }
  74.     } 
  75.     else if (scr_attr_flag == SCR_CONTENTS) {
  76.     for (row = minrow; row <= maxrow; row++) {
  77.         for (col = mincol; col <= maxcol; col++) {
  78.         *bufp = charyx(row,col);
  79.         if (!*bufp) *bufp = ' ';
  80.         else if (non_print_char && !isprint(*bufp)) /* check */
  81.             *bufp = non_print_char;
  82.         else if ((casep == SCR_IGNORE) && *bufp >= 'A' && *bufp <= 'Z')
  83.             *bufp += ('a'-'A');
  84.         bufp++;
  85.         }
  86.         if (row < maxrow) *bufp++ = '\n';
  87.     }
  88.     }
  89.     *bufp = '\0';
  90.     return(dumpbuf);
  91. }
  92.  
  93. /* get contents or attributes for specified screen_region */
  94. char *get_screen_region(sr)
  95. ScreenRegion *sr;
  96. {
  97.   int rowmin, rowmax, colmin, colmax;
  98.   long Cols = Session->columns;
  99.   long Rows = Session->rows;
  100.     
  101.   if (sr->relrowp == SCR_RELATIVE) {
  102.       rowmin = (sr->relrowmin + Session->y);
  103.       if (rowmin < sr->rowmin) {                /* check within clip region */
  104.       rowmin = sr->rowmin;          
  105.       } else if (rowmin > (Rows - 1)) { /* check within screen */
  106.       rowmin = (Rows - 1);   
  107.       }
  108.       rowmax = (sr->relrowmax + Session->y);
  109.       if (rowmax > sr->rowmax) {                 /* check within clip region */
  110.       rowmax = sr->rowmax;          
  111.       } else if (rowmax > (Rows - 1)) { /* check within screen */
  112.       rowmax = (Rows - 1);   
  113.       }
  114.       
  115.   } else {
  116.       rowmin = sr->rowmin;
  117.       rowmax = sr->rowmax;
  118.   }
  119.  
  120.   if (sr->relcolp == SCR_RELATIVE) {
  121.       colmin = (sr->relcolmin + Session->x);
  122.       if (colmin < sr->colmin) {                 /* check within clip region */
  123.       colmin = sr->colmin;          
  124.       } else if (colmin > (Cols - 1)) { /* check within screen */
  125.       colmin = (Cols - 1);   
  126.       }
  127.  
  128.       colmax = (sr->relcolmax + Session->x);
  129.       if (colmax > sr->colmax) {             /* check within clip region */
  130.       colmax = sr->colmax;          
  131.       } else if (colmax > (Cols - 1)) { /* check within screen */
  132.       colmax = (Cols - 1);   
  133.       }
  134.       
  135.   } else {
  136.       colmin = sr->colmin;
  137.       colmax = sr->colmax;
  138.   }
  139.  
  140.  
  141.   return ScreenDumpContents(rowmin, rowmax, colmin, colmax, sr->match_type, sr->non_print_char, sr->casep);
  142. }
  143.  
  144.  
  145. void
  146. init_screen_region(sr)
  147. ScreenRegion *sr;
  148. {
  149.   char *v;
  150.   
  151.   if ((v = get_var(CLIP_ROWMIN_VAR)) > (char *)0) sr->rowmin = atoi(v);
  152.   else sr->rowmin = 0;
  153.   if ((v = get_var(CLIP_ROWMAX_VAR)) > (char *)0) sr->rowmax = atoi(v);
  154.   else if (Session) sr->rowmax = (Session->rows - 1);
  155.   if ((v = get_var(CLIP_COLMIN_VAR)) > (char *)0) sr->colmin = atoi(v);
  156.   else sr->colmin = 0;
  157.   if ((v = get_var(CLIP_COLMAX_VAR)) > (char *)0) sr->colmax = atoi(v);
  158.   else if (Session) sr->colmax = (Session->columns - 1);
  159.  
  160.   sr->relrowmin = REL_ROWMIN_DEFAULT;
  161.   sr->relrowmax = REL_ROWMAX_DEFAULT;
  162.   sr->relcolmin = REL_COLMIN_DEFAULT;
  163.   sr->relcolmax = REL_COLMAX_DEFAULT;
  164.   sr->relrowp = SCR_ABSOLUTE;
  165.   sr->relcolp = SCR_ABSOLUTE;
  166.   sr->match_type = SCR_SERIAL;
  167.   sr->non_print_char = SCR_DEFAULT_NON_PRINT_CHAR;
  168.   sr->casep = SCR_NORMAL;
  169.   sr->breaksp = SCR_BREAKS;
  170. }
  171.  
  172. /*ARGSUSED*/
  173. int
  174. cmdScreenInfo(clientData, interp, argc, argv)
  175. ClientData clientData;
  176. Tcl_Interp *interp;
  177. int argc;
  178. char **argv;
  179. {
  180.   int m = -1;            /* master process file descriptor */
  181.   int i, screen_argp = 0; 
  182.   int previous_results = 0;
  183.   char temp_buf[128];
  184.   ScreenRegion sr_struct, *sr = &sr_struct;
  185.   
  186.   for (i=1;i<argc;i++) {
  187.     if (streq(argv[i],"-i")) {
  188.       if (argc == ++i) goto usage_error;
  189.       m = atoi(argv[i]);
  190.       break;
  191.     }
  192.   }
  193.   if ((m == -1) && (update_master(&m) == 0)) return(TCL_ERROR);
  194.  
  195.   if (!SetSessionFromFD(m)) {
  196.     tcl_error("spawn_id %d not associated with a terminal emulator.", m);
  197.     return TCL_ERROR;
  198.   }
  199.   
  200.   if (argc > 1) init_screen_region(sr);
  201.  
  202.   for (i=1;i<argc;i++) {
  203.     if (streq(argv[i],"-i")) {
  204.       ++i; continue;
  205.     } else if (streq(argv[i],"-numrows")) {
  206.       previous_results = 1;
  207.       sprintf(temp_buf,"%d",Session->rows);
  208.       Tcl_AppendElement(interp, temp_buf, 0);
  209.     } else if (streq(argv[i],"-numcols") || streq(argv[i],"-numcolumns")) {
  210.       previous_results = 1;
  211.       sprintf(temp_buf,"%d",Session->columns);
  212.       Tcl_AppendElement(interp, temp_buf, 0);
  213.     } else if (streq(argv[i],"-cursor_row")) {
  214.       previous_results = 1;
  215.       sprintf(temp_buf,"%d",Session->y);
  216.       Tcl_AppendElement(interp, temp_buf, 0);
  217.     } else if (streq(argv[i],"-cursor_col") || (streq(argv[i],"-cursor_column"))) {
  218.       previous_results = 1;
  219.       sprintf(temp_buf,"%d",Session->x);
  220.       Tcl_AppendElement(interp, temp_buf, 0);
  221.     } else if (streq(argv[i],"-info")) {
  222.       sprintf(interp->result,
  223.           "rows=%d:%d\ncols=%d:%d\nrrows=%d:%d\nrcols=%d:%d\nrelrowp=%s\nrelcolp=%s\nmatch_type=%s\nCase=%s\n",
  224.           sr->rowmin,sr->rowmax,sr->colmin, sr->colmax,
  225.           sr->relrowmin,sr->relrowmax,sr->relcolmin, sr->relcolmax,
  226.           ((sr->relrowp==SCR_RELATIVE)?"True":"False"), 
  227.           ((sr->relcolp==SCR_RELATIVE)?"True":"False"),
  228.           ((sr->match_type==SCR_ATTRIBUTES)?"Attributes":
  229.            (sr->match_type==SCR_CONTENTS)?"Contents":
  230.            (sr->match_type==SCR_SERIAL)?"Serial":
  231.            "*Unknown*"),
  232.           ((sr->casep == SCR_IGNORE)?"Ignore":"Normal")
  233.           );
  234.       return TCL_OK; 
  235.     } else if (parse_screen_argument(argc, argv, &i, sr)) {
  236.       if (i == -1) return TCL_ERROR;
  237.       screen_argp = 1;
  238.     } else if (streq(argv[i],"-nocase")) {
  239.       sr->match_type = SCR_CONTENTS;
  240.       screen_argp = 1;
  241.     } else goto usage_error;
  242.   }
  243.   if (screen_argp) {
  244.     if (previous_results) Tcl_AppendElement(interp, get_screen_region(sr), TCL_STATIC);
  245.     else Tcl_SetResult(interp, get_screen_region(sr), TCL_STATIC);
  246.   }
  247.   else if (!previous_results) {
  248.     Tcl_SetResult(interp, 
  249.           ScreenDumpContents(0,(Session->rows - 1),0, (Session->columns - 1), 
  250.                      SCR_CONTENTS,0,SCR_NORMAL), 
  251.           TCL_STATIC);
  252.   }
  253.   return TCL_OK;
  254.   
  255.  usage_error:
  256.   tcl_error("usage: %s [-i spawn_id] [-nocase] [-numrows] [-numcols] [-cursor_row] [-cursor_col] [screen region]", argv[0]);
  257.   return TCL_ERROR;
  258.   
  259. }
  260.  
  261. int
  262. parse_screen_argument(argc, argv, i, sr)
  263. int argc, *i;
  264. char **argv;
  265. ScreenRegion *sr;
  266. {
  267.   int min, max;
  268.   extern double atof();
  269.  
  270.   if (streq(argv[*i],"-screen") || streq(argv[*i],"-scr")) {
  271.       sr->match_type = SCR_CONTENTS;
  272.   } else if ((streq(argv[*i],"-attr")) || (streq(argv[*i],"-attributes"))) {
  273.       sr->match_type = SCR_ATTRIBUTES;
  274.   } else if (streq(argv[*i],"-serial")) {
  275.     sr->match_type = SCR_SERIAL;
  276.   } else if (streq(argv[*i],"-nocase")) {
  277.     sr->casep = SCR_IGNORE;
  278.     return(0);    /* return 0 so expect can reuse -nocase flag */
  279.   } else if (streq(argv[*i],"-nobreaks")) {
  280.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  281.     sr->breaksp = SCR_NOBREAKS;
  282.   } else if (streq(argv[*i],"-breaks")) {
  283.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  284.     sr->breaksp = SCR_BREAKS;
  285.   } else if (streq(argv[*i],"-breaks")) {
  286.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  287.     sr->breaksp = SCR_BREAKS;
  288.   } else if (streq(argv[*i],"-cols") || streq(argv[*i],"-columns") || 
  289.          streq(argv[*i],"-clipcol") || streq(argv[*i],"-clipcolumn")) {
  290.     if (parse_min_max((*i+1==argc), argv[*i+1], &min, &max,
  291.               -(Session->columns-1), (Session->columns-1))
  292.     == TCL_ERROR) goto number_error;
  293.     ++(*i);
  294.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  295.     if (min < 0) min = min + Session->columns;
  296.     if (max < 0) max = max + Session->columns;
  297.     if (sr->colmin < min) sr->colmin = min;
  298.     if (sr->colmax > max) sr->colmax = max;
  299.   } else if (streq(argv[*i],"-rows") || streq(argv[*i],"-cliprow")) {
  300.     if (parse_min_max((*i+1==argc), argv[*i+1], &min, &max, -(Session->rows - 1), (Session->rows - 1))
  301.     == TCL_ERROR) goto number_error;
  302.     ++(*i);
  303.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  304.     if (min < 0) min = min + Session->rows;
  305.     if (max < 0) max = max + Session->rows;
  306.     if (sr->rowmin < min) sr->rowmin = min;
  307.     if (sr->rowmax > max) sr->rowmax = max;
  308.   } else if (streq(argv[*i],"-rcols") || streq(argv[*i],"-rcolumns")) {
  309.     if (parse_min_max((*i+1==argc), argv[*i+1], &min, &max, -(Session->columns - 1), (Session->columns - 1))
  310.     == TCL_ERROR) goto number_error;
  311.     ++(*i);
  312.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  313.     sr->relcolmin += min;
  314.     sr->relcolmax += max;
  315.     sr->relcolp = SCR_RELATIVE;
  316.   } else if (streq(argv[*i],"-rrows")) {
  317.     if (parse_min_max((*i+1==argc), argv[*i+1], &min, &max, -(Session->rows - 1), (Session->rows - 1))
  318.     == TCL_ERROR) goto number_error;
  319.     ++(*i);
  320.     if (sr->match_type == SCR_SERIAL) sr->match_type = SCR_CONTENTS;
  321.     sr->relrowmin += min;
  322.     sr->relrowmax += max;
  323.     sr->relrowp = SCR_RELATIVE;
  324.   } else if (streq(argv[*i],"-nonprint")) {
  325.     if ((*i+1) == argc) goto usage_error;
  326.     ++(*i);
  327.     sr->match_type = SCR_CONTENTS;
  328.     sr->non_print_char = argv[*i][0];
  329.   } else return 0;        /* argv[*i] is not a screen argument */
  330.   
  331.   return 1;        /* argv[*i] is a screen argument; return new index */
  332.   
  333.  usage_error:
  334.   tcl_error("error parsing %s argument: %s", argv[0], argv[*i]);
  335.   return (*i = -1);
  336.  
  337.  number_error:
  338.   tcl_error("badly formed number or range for %s: %s", argv[*i-1], argv[*i]);
  339.   return (*i = -1);
  340. }
  341.  
  342. int parse_min_max(argc_error, argument, min, max, absmin, absmax)
  343. char *argument;
  344. int argc_error, *min, *max;
  345. {
  346.     char argbuf[128], *arg;
  347.     char *minptr, *maxptr;
  348.     
  349.     if (argc_error) return TCL_ERROR;
  350.  
  351.     strcpy(argbuf, argument);
  352.     minptr = maxptr = arg = argbuf;
  353.     for (;*arg;arg++) {
  354.     if (*arg == ':') {
  355.         *arg = '\0';
  356.         maxptr = arg+1;
  357.     } else if (!(*arg == '$' || *arg == '^' || *arg == '-' || isdigit(*arg)))
  358.         return TCL_ERROR;
  359.     }
  360.  
  361.     *min = my_atoi(minptr, absmin, absmax);
  362.     if (*min < absmin) *min = absmin;
  363.     *max = my_atoi(maxptr, absmin, absmax);
  364.     if (*max > absmax) *max = absmax;
  365.  
  366.     return TCL_OK;
  367. }
  368.  
  369. int my_atoi(n, absmin, absmax)
  370. char *n;
  371. int absmin, absmax;
  372. {
  373.    if (*n == '$') return absmax;
  374.    if (*n == '^') return absmin;
  375.    return atoi(n);
  376. }
  377.  
  378. void
  379. init_scr_region_variables()
  380. {
  381.   Tcl_SetVar(interp,CLIP_ROWMIN_VAR,"-1",0);
  382.   Tcl_SetVar(interp,CLIP_ROWMAX_VAR,"-1",0);
  383.   Tcl_SetVar(interp,CLIP_COLMIN_VAR,"-1",0);
  384.   Tcl_SetVar(interp,CLIP_COLMAX_VAR,"-1",0);
  385. }
  386.  
  387.  
  388. int get_start_row(sr, start)
  389. ScreenRegion *sr;
  390. int start;
  391. {
  392.   int row, cols, result=0;
  393.   if (sr->relrowp == 'r') row = Session->y + sr->relrowmin;
  394.   else row = sr->rowmin;
  395.   if (sr->relcolp == 'r') cols = sr->relcolmax - sr->relcolmin;
  396.   else cols = sr->colmax - sr->colmin + 2;
  397.   if (cols) result = (row + (start / cols));
  398.   return(result);
  399. }
  400.  
  401. int get_start_col(sr, start)
  402. ScreenRegion *sr;
  403. int start;
  404. { int col, cols;
  405.   if (sr->relcolp == 'r') col = Session->x + sr->relcolmin;
  406.   else col = sr->colmin;
  407.   if (sr->relcolp == 'r') cols = sr->relcolmax - sr->relcolmin;
  408.   else cols = sr->colmax - sr->colmin + 2;
  409.   if (cols) return (col + (start % cols));
  410.   else return 0;
  411. }
  412.